package com.rd.teacher.jichao.day21;

import java.util.Arrays;

public class TestSort {


    public static void main(String[] args) {
//        int[] arr = {60, 77, 33, 55, 11, 22, 80};
        int[] arr = {60, 77, 33, 55, 88, 90, 99};
//        int[] arr = {11, 22, 33, 55, 60, 77, 80};
//        test(arr);
        test2(arr);
    }

    public static void test(int[] arr) {
        // 实现冒泡  从头开始遍历数组
        //  遍历的是 相邻的元素  是否符合排序的位置
        //  比如 从小到大  在大的值在前  小的值在后时 需要替换
        for (int i = 0; i < arr.length - 1; i++) {
            // 比较多少轮次   长度-1
            for (int j = 0; j < arr.length - 1 - i; j++) {
                // 每一轮比较多少次   长度-1-轮次
                // 取决于这是第几轮  第i轮
                System.out.println(i + "," + j);
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                    System.out.println(Arrays.toString(arr));
                }
            }
            System.out.println("------");
        }
    }


    public static void test1(int[] arr) {
        // 实现冒泡  从头开始遍历数组
        //  遍历的是 相邻的元素  是否符合排序的位置
        //  比如 从小到大  在大的值在前  小的值在后时 需要替换

        for (int i = 0; i < arr.length - 1; i++) {
            // 比较多少轮次   长度-1
            // 假设有序
            boolean isSorted = true;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                // 每一轮比较多少次   长度-1-轮次
                // 取决于这是第几轮  第i轮
                System.out.println(i + "," + j);
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                    System.out.println(Arrays.toString(arr));
                    // 当交换产生  说明无序
                    isSorted = false;
                }
            }
            // 如果已经有序  跳出外层循环
            if (isSorted) break;
            System.out.println("------");
        }
    }

    public static void test2(int[] arr) {
        // 实现冒泡  从头开始遍历数组
        //  遍历的是 相邻的元素  是否符合排序的位置
        //  比如 从小到大  在大的值在前  小的值在后时 需要替换

        // 记录每次交换的位置
        int changeIndex = 0;
        // 记录最后一次交换的位置
        int lastChangeIndex = arr.length - 1;
        for (int i = 0; i < arr.length - 1; i++) {
            // 比较多少轮次   长度-1
            // 假设有序
            boolean isSorted = true;
            // 怎么记录最后交换的位置
            // 如果每一次交换都记录它的位置   那么当循环结束后 留下的就是最后一次交换的位置
            for (int j = 0; j < lastChangeIndex; j++) {
                // 每一轮比较多少次   长度-1-轮次
                // 取决于这是第几轮  第i轮
                System.out.println(i + "," + j);
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;

                    // 当交换产生  说明无序
                    isSorted = false;
                    changeIndex = j;
                    System.out.println(changeIndex);
                    System.out.println(Arrays.toString(arr));
                }
            }
            lastChangeIndex = changeIndex;
            System.out.println(lastChangeIndex);
            // 如果已经有序  跳出外层循环
            if (isSorted) break;
            System.out.println("------");
        }
    }

}
